//C-  -*- C++ -*-
//C- -------------------------------------------------------------------
//C- DjVuLibre-3.5
//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
//C- Copyright (c) 2001  AT&T
//C-
//C- This software is subject to, and may be distributed under, the
//C- GNU General Public License, either Version 2 of the license,
//C- or (at your option) any later version. The license should have
//C- accompanied the software or you may obtain a copy of the license
//C- from the Free Software Foundation at http://www.fsf.org .
//C-
//C- This program is distributed in the hope that it will be useful,
//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//C- GNU General Public License for more details.
//C- 
//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from
//C- Lizardtech Software.  Lizardtech Software has authorized us to
//C- replace the original DjVu(r) Reference Library notice by the following
//C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):
//C-
//C-  ------------------------------------------------------------------
//C- | DjVu (r) Reference Library (v. 3.5)
//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
//C- | The DjVu Reference Library is protected by U.S. Pat. No.
//C- | 6,058,214 and patents pending.
//C- |
//C- | This software is subject to, and may be distributed under, the
//C- | GNU General Public License, either Version 2 of the license,
//C- | or (at your option) any later version. The license should have
//C- | accompanied the software or you may obtain a copy of the license
//C- | from the Free Software Foundation at http://www.fsf.org .
//C- |
//C- | The computer code originally released by LizardTech under this
//C- | license and unmodified by other parties is deemed "the LIZARDTECH
//C- | ORIGINAL CODE."  Subject to any third party intellectual property
//C- | claims, LizardTech grants recipient a worldwide, royalty-free, 
//C- | non-exclusive license to make, use, sell, or otherwise dispose of 
//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 
//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 
//C- | General Public License.   This grant only confers the right to 
//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 
//C- | the extent such infringement is reasonably necessary to enable 
//C- | recipient to make, have made, practice, sell, or otherwise dispose 
//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 
//C- | any greater extent that may be necessary to utilize further 
//C- | modifications or combinations.
//C- |
//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//C- +------------------------------------------------------------------

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#if NEED_GNUG_PRAGMAS
# pragma implementation
#endif

// From: Leon Bottou, 1/31/2002
// Almost equal to my initial code.

#include "ZPCodec.h"
#include "ByteStream.h"
#include "GException.h"

#include <stddef.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdio.h>


#ifdef HAVE_NAMESPACES
namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
}
#endif
#endif

////////////////////////////////////////////////////////////////
// CODER SPECIFICATION
////////////////////////////////////////////////////////////////


#ifndef ZPCODER
#ifndef ZCODER
#define ZPCODER
#endif
#endif
#ifdef ZCODER

// The ZCODER option is provided for documentation purposes only. The ZCODER
// might come dangerously close to U.S. patent 5059976 (Mitsubishi).  This is
// why we always use the ZPCODER, although it usually produces 1% larger files.
#warning "The ZCODER may infringe non-LizardTech patent(s)."
#warning "You should use the ZPCODER instead."
#endif


////////////////////////////////////////////////////////////////
// ZP CODER DEFAULT ADAPTATION TABLE
////////////////////////////////////////////////////////////////


// See ZPCodec::ZPCodec to see how this
// default table is modified when not
// using the DjVu compatibility mode.


static ZPCodec::Table default_ztable[256] = 
{
#ifdef ZPCODER
  /* This table has been designed for the ZPCoder
   * by running the following command in file 'zptable.sn':
   * (fast-crude (steady-mat 0.0035  0.0002) 260)))
   */
  { 0x8000,  0x0000,  84, 145 },    /* 000: p=0.500000 (    0,    0) */
  { 0x8000,  0x0000,   3,   4 },    /* 001: p=0.500000 (    0,    0) */
  { 0x8000,  0x0000,   4,   3 },    /* 002: p=0.500000 (    0,    0) */
  { 0x6bbd,  0x10a5,   5,   1 },    /* 003: p=0.465226 (    0,    0) */
  { 0x6bbd,  0x10a5,   6,   2 },    /* 004: p=0.465226 (    0,    0) */
  { 0x5d45,  0x1f28,   7,   3 },    /* 005: p=0.430708 (    0,    0) */
  { 0x5d45,  0x1f28,   8,   4 },    /* 006: p=0.430708 (    0,    0) */
  { 0x51b9,  0x2bd3,   9,   5 },    /* 007: p=0.396718 (    0,    0) */
  { 0x51b9,  0x2bd3,  10,   6 },    /* 008: p=0.396718 (    0,    0) */
  { 0x4813,  0x36e3,  11,   7 },    /* 009: p=0.363535 (    0,    0) */
  { 0x4813,  0x36e3,  12,   8 },    /* 010: p=0.363535 (    0,    0) */
  { 0x3fd5,  0x408c,  13,   9 },    /* 011: p=0.331418 (    0,    0) */
  { 0x3fd5,  0x408c,  14,  10 },    /* 012: p=0.331418 (    0,    0) */
  { 0x38b1,  0x48fd,  15,  11 },    /* 013: p=0.300585 (    0,    0) */
  { 0x38b1,  0x48fd,  16,  12 },    /* 014: p=0.300585 (    0,    0) */
  { 0x3275,  0x505d,  17,  13 },    /* 015: p=0.271213 (    0,    0) */
  { 0x3275,  0x505d,  18,  14 },    /* 016: p=0.271213 (    0,    0) */
  { 0x2cfd,  0x56d0,  19,  15 },    /* 017: p=0.243438 (    0,    0) */
  { 0x2cfd,  0x56d0,  20,  16 },    /* 018: p=0.243438 (    0,    0) */
  { 0x2825,  0x5c71,  21,  17 },    /* 019: p=0.217391 (    0,    0) */
  { 0x2825,  0x5c71,  22,  18 },    /* 020: p=0.217391 (    0,    0) */
  { 0x23ab,  0x615b,  23,  19 },    /* 021: p=0.193150 (    0,    0) */
  { 0x23ab,  0x615b,  24,  20 },    /* 022: p=0.193150 (    0,    0) */
  { 0x1f87,  0x65a5,  25,  21 },    /* 023: p=0.170728 (    0,    0) */
  { 0x1f87,  0x65a5,  26,  22 },    /* 024: p=0.170728 (    0,    0) */
  { 0x1bbb,  0x6962,  27,  23 },    /* 025: p=0.150158 (    0,    0) */
  { 0x1bbb,  0x6962,  28,  24 },    /* 026: p=0.150158 (    0,    0) */
  { 0x1845,  0x6ca2,  29,  25 },    /* 027: p=0.131418 (    0,    0) */
  { 0x1845,  0x6ca2,  30,  26 },    /* 028: p=0.131418 (    0,    0) */
  { 0x1523,  0x6f74,  31,  27 },    /* 029: p=0.114460 (    0,    0) */
  { 0x1523,  0x6f74,  32,  28 },    /* 030: p=0.114460 (    0,    0) */
  { 0x1253,  0x71e6,  33,  29 },    /* 031: p=0.099230 (    0,    0) */
  { 0x1253,  0x71e6,  34,  30 },    /* 032: p=0.099230 (    0,    0) */
  { 0x0fcf,  0x7404,  35,  31 },    /* 033: p=0.085611 (    0,    0) */
  { 0x0fcf,  0x7404,  36,  32 },    /* 034: p=0.085611 (    0,    0) */
  { 0x0d95,  0x75d6,  37,  33 },    /* 035: p=0.073550 (    0,    0) */
  { 0x0d95,  0x75d6,  38,  34 },    /* 036: p=0.073550 (    0,    0) */
  { 0x0b9d,  0x7768,  39,  35 },    /* 037: p=0.062888 (    0,    0) */
  { 0x0b9d,  0x7768,  40,  36 },    /* 038: p=0.062888 (    0,    0) */
  { 0x09e3,  0x78c2,  41,  37 },    /* 039: p=0.053539 (    0,    0) */
  { 0x09e3,  0x78c2,  42,  38 },    /* 040: p=0.053539 (    0,    0) */
  { 0x0861,  0x79ea,  43,  39 },    /* 041: p=0.045365 (    0,    0) */
  { 0x0861,  0x79ea,  44,  40 },    /* 042: p=0.045365 (    0,    0) */
  { 0x0711,  0x7ae7,  45,  41 },    /* 043: p=0.038272 (    0,    0) */
  { 0x0711,  0x7ae7,  46,  42 },    /* 044: p=0.038272 (    0,    0) */
  { 0x05f1,  0x7bbe,  47,  43 },    /* 045: p=0.032174 (    0,    0) */
  { 0x05f1,  0x7bbe,  48,  44 },    /* 046: p=0.032174 (    0,    0) */
  { 0x04f9,  0x7c75,  49,  45 },    /* 047: p=0.026928 (    0,    0) */
  { 0x04f9,  0x7c75,  50,  46 },    /* 048: p=0.026928 (    0,    0) */
  { 0x0425,  0x7d0f,  51,  47 },    /* 049: p=0.022444 (    0,    0) */
  { 0x0425,  0x7d0f,  52,  48 },    /* 050: p=0.022444 (    0,    0) */
  { 0x0371,  0x7d91,  53,  49 },    /* 051: p=0.018636 (    0,    0) */
  { 0x0371,  0x7d91,  54,  50 },    /* 052: p=0.018636 (    0,    0) */
  { 0x02d9,  0x7dfe,  55,  51 },    /* 053: p=0.015421 (    0,    0) */
  { 0x02d9,  0x7dfe,  56,  52 },    /* 054: p=0.015421 (    0,    0) */
  { 0x0259,  0x7e5a,  57,  53 },    /* 055: p=0.012713 (    0,    0) */
  { 0x0259,  0x7e5a,  58,  54 },    /* 056: p=0.012713 (    0,    0) */
  { 0x01ed,  0x7ea6,  59,  55 },    /* 057: p=0.010419 (    0,    0) */
  { 0x01ed,  0x7ea6,  60,  56 },    /* 058: p=0.010419 (    0,    0) */
  { 0x0193,  0x7ee6,  61,  57 },    /* 059: p=0.008525 (    0,    0) */
  { 0x0193,  0x7ee6,  62,  58 },    /* 060: p=0.008525 (    0,    0) */
  { 0x0149,  0x7f1a,  63,  59 },    /* 061: p=0.006959 (    0,    0) */
  { 0x0149,  0x7f1a,  64,  60 },    /* 062: p=0.006959 (    0,    0) */
  { 0x010b,  0x7f45,  65,  61 },    /* 063: p=0.005648 (    0,    0) */
  { 0x010b,  0x7f45,  66,  62 },    /* 064: p=0.005648 (    0,    0) */
  { 0x00d5,  0x7f6b,  67,  63 },    /* 065: p=0.004506 (    0,    0) */
  { 0x00d5,  0x7f6b,  68,  64 },    /* 066: p=0.004506 (    0,    0) */
  { 0x00a5,  0x7f8d,  69,  65 },    /* 067: p=0.003480 (    0,    0) */
  { 0x00a5,  0x7f8d,  70,  66 },    /* 068: p=0.003480 (    0,    0) */
  { 0x007b,  0x7faa,  71,  67 },    /* 069: p=0.002602 (    0,    0) */
  { 0x007b,  0x7faa,  72,  68 },    /* 070: p=0.002602 (    0,    0) */
  { 0x0057,  0x7fc3,  73,  69 },    /* 071: p=0.001843 (    0,    0) */
  { 0x0057,  0x7fc3,  74,  70 },    /* 072: p=0.001843 (    0,    0) */
  { 0x003b,  0x7fd7,  75,  71 },    /* 073: p=0.001248 (    0,    0) */
  { 0x003b,  0x7fd7,  76,  72 },    /* 074: p=0.001248 (    0,    0) */
  { 0x0023,  0x7fe7,  77,  73 },    /* 075: p=0.000749 (    0,    0) */
  { 0x0023,  0x7fe7,  78,  74 },    /* 076: p=0.000749 (    0,    0) */
  { 0x0013,  0x7ff2,  79,  75 },    /* 077: p=0.000402 (    0,    0) */
  { 0x0013,  0x7ff2,  80,  76 },    /* 078: p=0.000402 (    0,    0) */
  { 0x0007,  0x7ffa,  81,  77 },    /* 079: p=0.000153 (    0,    0) */
  { 0x0007,  0x7ffa,  82,  78 },    /* 080: p=0.000153 (    0,    0) */
  { 0x0001,  0x7fff,  81,  79 },    /* 081: p=0.000027 (    0,    0) */
  { 0x0001,  0x7fff,  82,  80 },    /* 082: p=0.000027 (    0,    0) */
  { 0x5695,  0x0000,   9,  85 },    /* 083: p=0.411764 (    2,    3) */
  { 0x24ee,  0x0000,  86, 226 },    /* 084: p=0.199988 (    1,    0) */
  { 0x8000,  0x0000,   5,   6 },    /* 085: p=0.500000 (    3,    3) */
  { 0x0d30,  0x0000,  88, 176 },    /* 086: p=0.071422 (    4,    0) */
  { 0x481a,  0x0000,  89, 143 },    /* 087: p=0.363634 (    1,    2) */
  { 0x0481,  0x0000,  90, 138 },    /* 088: p=0.024388 (   13,    0) */
  { 0x3579,  0x0000,  91, 141 },    /* 089: p=0.285711 (    1,    3) */
  { 0x017a,  0x0000,  92, 112 },    /* 090: p=0.007999 (   41,    0) */
  { 0x24ef,  0x0000,  93, 135 },    /* 091: p=0.199997 (    1,    5) */
  { 0x007b,  0x0000,  94, 104 },    /* 092: p=0.002611 (  127,    0) */
  { 0x1978,  0x0000,  95, 133 },    /* 093: p=0.137929 (    1,    8) */
  { 0x0028,  0x0000,  96, 100 },    /* 094: p=0.000849 (  392,    0) */
  { 0x10ca,  0x0000,  97, 129 },    /* 095: p=0.090907 (    1,   13) */
  { 0x000d,  0x0000,  82,  98 },    /* 096: p=0.000276 ( 1208,    0) */
  { 0x0b5d,  0x0000,  99, 127 },    /* 097: p=0.061537 (    1,   20) */
  { 0x0034,  0x0000,  76,  72 },    /* 098: p=0.001102 ( 1208,    1) */
  { 0x078a,  0x0000, 101, 125 },    /* 099: p=0.040815 (    1,   31) */
  { 0x00a0,  0x0000,  70, 102 },    /* 100: p=0.003387 (  392,    1) */
  { 0x050f,  0x0000, 103, 123 },    /* 101: p=0.027397 (    1,   47) */
  { 0x0117,  0x0000,  66,  60 },    /* 102: p=0.005912 (  392,    2) */
  { 0x0358,  0x0000, 105, 121 },    /* 103: p=0.018099 (    1,   72) */
  { 0x01ea,  0x0000, 106, 110 },    /* 104: p=0.010362 (  127,    1) */
  { 0x0234,  0x0000, 107, 119 },    /* 105: p=0.011940 (    1,  110) */
  { 0x0144,  0x0000,  66, 108 },    /* 106: p=0.006849 (  193,    1) */
  { 0x0173,  0x0000, 109, 117 },    /* 107: p=0.007858 (    1,  168) */
  { 0x0234,  0x0000,  60,  54 },    /* 108: p=0.011925 (  193,    2) */
  { 0x00f5,  0x0000, 111, 115 },    /* 109: p=0.005175 (    1,  256) */
  { 0x0353,  0x0000,  56,  48 },    /* 110: p=0.017995 (  127,    2) */
  { 0x00a1,  0x0000,  69, 113 },    /* 111: p=0.003413 (    1,  389) */
  { 0x05c5,  0x0000, 114, 134 },    /* 112: p=0.031249 (   41,    1) */
  { 0x011a,  0x0000,  65,  59 },    /* 113: p=0.005957 (    2,  389) */
  { 0x03cf,  0x0000, 116, 132 },    /* 114: p=0.020618 (   63,    1) */
  { 0x01aa,  0x0000,  61,  55 },    /* 115: p=0.009020 (    2,  256) */
  { 0x0285,  0x0000, 118, 130 },    /* 116: p=0.013652 (   96,    1) */
  { 0x0286,  0x0000,  57,  51 },    /* 117: p=0.013672 (    2,  168) */
  { 0x01ab,  0x0000, 120, 128 },    /* 118: p=0.009029 (  146,    1) */
  { 0x03d3,  0x0000,  53,  47 },    /* 119: p=0.020710 (    2,  110) */
  { 0x011a,  0x0000, 122, 126 },    /* 120: p=0.005961 (  222,    1) */
  { 0x05c5,  0x0000,  49,  41 },    /* 121: p=0.031250 (    2,   72) */
  { 0x00ba,  0x0000, 124,  62 },    /* 122: p=0.003925 (  338,    1) */
  { 0x08ad,  0x0000,  43,  37 },    /* 123: p=0.046979 (    2,   47) */
  { 0x007a,  0x0000,  72,  66 },    /* 124: p=0.002586 (  514,    1) */
  { 0x0ccc,  0x0000,  39,  31 },    /* 125: p=0.069306 (    2,   31) */
  { 0x01eb,  0x0000,  60,  54 },    /* 126: p=0.010386 (  222,    2) */
  { 0x1302,  0x0000,  33,  25 },    /* 127: p=0.102940 (    2,   20) */
  { 0x02e6,  0x0000,  56,  50 },    /* 128: p=0.015695 (  146,    2) */
  { 0x1b81,  0x0000,  29, 131 },    /* 129: p=0.148935 (    2,   13) */
  { 0x045e,  0x0000,  52,  46 },    /* 130: p=0.023648 (   96,    2) */
  { 0x24ef,  0x0000,  23,  17 },    /* 131: p=0.199999 (    3,   13) */
  { 0x0690,  0x0000,  48,  40 },    /* 132: p=0.035533 (   63,    2) */
  { 0x2865,  0x0000,  23,  15 },    /* 133: p=0.218748 (    2,    8) */
  { 0x09de,  0x0000,  42, 136 },    /* 134: p=0.053434 (   41,    2) */
  { 0x3987,  0x0000, 137,   7 },    /* 135: p=0.304346 (    2,    5) */
  { 0x0dc8,  0x0000,  38,  32 },    /* 136: p=0.074626 (   41,    3) */
  { 0x2c99,  0x0000,  21, 139 },    /* 137: p=0.241378 (    2,    7) */
  { 0x10ca,  0x0000, 140, 172 },    /* 138: p=0.090907 (   13,    1) */
  { 0x3b5f,  0x0000,  15,   9 },    /* 139: p=0.312499 (    3,    7) */
  { 0x0b5d,  0x0000, 142, 170 },    /* 140: p=0.061537 (   20,    1) */
  { 0x5695,  0x0000,   9,  85 },    /* 141: p=0.411764 (    2,    3) */
  { 0x078a,  0x0000, 144, 168 },    /* 142: p=0.040815 (   31,    1) */
  { 0x8000,  0x0000, 141, 248 },    /* 143: p=0.500000 (    2,    2) */
  { 0x050f,  0x0000, 146, 166 },    /* 144: p=0.027397 (   47,    1) */
  { 0x24ee,  0x0000, 147, 247 },    /* 145: p=0.199988 (    0,    1) */
  { 0x0358,  0x0000, 148, 164 },    /* 146: p=0.018099 (   72,    1) */
  { 0x0d30,  0x0000, 149, 197 },    /* 147: p=0.071422 (    0,    4) */
  { 0x0234,  0x0000, 150, 162 },    /* 148: p=0.011940 (  110,    1) */
  { 0x0481,  0x0000, 151,  95 },    /* 149: p=0.024388 (    0,   13) */
  { 0x0173,  0x0000, 152, 160 },    /* 150: p=0.007858 (  168,    1) */
  { 0x017a,  0x0000, 153, 173 },    /* 151: p=0.007999 (    0,   41) */
  { 0x00f5,  0x0000, 154, 158 },    /* 152: p=0.005175 (  256,    1) */
  { 0x007b,  0x0000, 155, 165 },    /* 153: p=0.002611 (    0,  127) */
  { 0x00a1,  0x0000,  70, 156 },    /* 154: p=0.003413 (  389,    1) */
  { 0x0028,  0x0000, 157, 161 },    /* 155: p=0.000849 (    0,  392) */
  { 0x011a,  0x0000,  66,  60 },    /* 156: p=0.005957 (  389,    2) */
  { 0x000d,  0x0000,  81, 159 },    /* 157: p=0.000276 (    0, 1208) */
  { 0x01aa,  0x0000,  62,  56 },    /* 158: p=0.009020 (  256,    2) */
  { 0x0034,  0x0000,  75,  71 },    /* 159: p=0.001102 (    1, 1208) */
  { 0x0286,  0x0000,  58,  52 },    /* 160: p=0.013672 (  168,    2) */
  { 0x00a0,  0x0000,  69, 163 },    /* 161: p=0.003387 (    1,  392) */
  { 0x03d3,  0x0000,  54,  48 },    /* 162: p=0.020710 (  110,    2) */
  { 0x0117,  0x0000,  65,  59 },    /* 163: p=0.005912 (    2,  392) */
  { 0x05c5,  0x0000,  50,  42 },    /* 164: p=0.031250 (   72,    2) */
  { 0x01ea,  0x0000, 167, 171 },    /* 165: p=0.010362 (    1,  127) */
  { 0x08ad,  0x0000,  44,  38 },    /* 166: p=0.046979 (   47,    2) */
  { 0x0144,  0x0000,  65, 169 },    /* 167: p=0.006849 (    1,  193) */
  { 0x0ccc,  0x0000,  40,  32 },    /* 168: p=0.069306 (   31,    2) */
  { 0x0234,  0x0000,  59,  53 },    /* 169: p=0.011925 (    2,  193) */
  { 0x1302,  0x0000,  34,  26 },    /* 170: p=0.102940 (   20,    2) */
  { 0x0353,  0x0000,  55,  47 },    /* 171: p=0.017995 (    2,  127) */
  { 0x1b81,  0x0000,  30, 174 },    /* 172: p=0.148935 (   13,    2) */
  { 0x05c5,  0x0000, 175, 193 },    /* 173: p=0.031249 (    1,   41) */
  { 0x24ef,  0x0000,  24,  18 },    /* 174: p=0.199999 (   13,    3) */
  { 0x03cf,  0x0000, 177, 191 },    /* 175: p=0.020618 (    1,   63) */
  { 0x2b74,  0x0000, 178, 222 },    /* 176: p=0.235291 (    4,    1) */
  { 0x0285,  0x0000, 179, 189 },    /* 177: p=0.013652 (    1,   96) */
  { 0x201d,  0x0000, 180, 218 },    /* 178: p=0.173910 (    6,    1) */
  { 0x01ab,  0x0000, 181, 187 },    /* 179: p=0.009029 (    1,  146) */
  { 0x1715,  0x0000, 182, 216 },    /* 180: p=0.124998 (    9,    1) */
  { 0x011a,  0x0000, 183, 185 },    /* 181: p=0.005961 (    1,  222) */
  { 0x0fb7,  0x0000, 184, 214 },    /* 182: p=0.085105 (   14,    1) */
  { 0x00ba,  0x0000,  69,  61 },    /* 183: p=0.003925 (    1,  338) */
  { 0x0a67,  0x0000, 186, 212 },    /* 184: p=0.056337 (   22,    1) */
  { 0x01eb,  0x0000,  59,  53 },    /* 185: p=0.010386 (    2,  222) */
  { 0x06e7,  0x0000, 188, 210 },    /* 186: p=0.037382 (   34,    1) */
  { 0x02e6,  0x0000,  55,  49 },    /* 187: p=0.015695 (    2,  146) */
  { 0x0496,  0x0000, 190, 208 },    /* 188: p=0.024844 (   52,    1) */
  { 0x045e,  0x0000,  51,  45 },    /* 189: p=0.023648 (    2,   96) */
  { 0x030d,  0x0000, 192, 206 },    /* 190: p=0.016529 (   79,    1) */
  { 0x0690,  0x0000,  47,  39 },    /* 191: p=0.035533 (    2,   63) */
  { 0x0206,  0x0000, 194, 204 },    /* 192: p=0.010959 (  120,    1) */
  { 0x09de,  0x0000,  41, 195 },    /* 193: p=0.053434 (    2,   41) */
  { 0x0155,  0x0000, 196, 202 },    /* 194: p=0.007220 (  183,    1) */
  { 0x0dc8,  0x0000,  37,  31 },    /* 195: p=0.074626 (    3,   41) */
  { 0x00e1,  0x0000, 198, 200 },    /* 196: p=0.004750 (  279,    1) */
  { 0x2b74,  0x0000, 199, 243 },    /* 197: p=0.235291 (    1,    4) */
  { 0x0094,  0x0000,  72,  64 },    /* 198: p=0.003132 (  424,    1) */
  { 0x201d,  0x0000, 201, 239 },    /* 199: p=0.173910 (    1,    6) */
  { 0x0188,  0x0000,  62,  56 },    /* 200: p=0.008284 (  279,    2) */
  { 0x1715,  0x0000, 203, 237 },    /* 201: p=0.124998 (    1,    9) */
  { 0x0252,  0x0000,  58,  52 },    /* 202: p=0.012567 (  183,    2) */
  { 0x0fb7,  0x0000, 205, 235 },    /* 203: p=0.085105 (    1,   14) */
  { 0x0383,  0x0000,  54,  48 },    /* 204: p=0.019021 (  120,    2) */
  { 0x0a67,  0x0000, 207, 233 },    /* 205: p=0.056337 (    1,   22) */
  { 0x0547,  0x0000,  50,  44 },    /* 206: p=0.028571 (   79,    2) */
  { 0x06e7,  0x0000, 209, 231 },    /* 207: p=0.037382 (    1,   34) */
  { 0x07e2,  0x0000,  46,  38 },    /* 208: p=0.042682 (   52,    2) */
  { 0x0496,  0x0000, 211, 229 },    /* 209: p=0.024844 (    1,   52) */
  { 0x0bc0,  0x0000,  40,  34 },    /* 210: p=0.063636 (   34,    2) */
  { 0x030d,  0x0000, 213, 227 },    /* 211: p=0.016529 (    1,   79) */
  { 0x1178,  0x0000,  36,  28 },    /* 212: p=0.094593 (   22,    2) */
  { 0x0206,  0x0000, 215, 225 },    /* 213: p=0.010959 (    1,  120) */
  { 0x19da,  0x0000,  30,  22 },    /* 214: p=0.139999 (   14,    2) */
  { 0x0155,  0x0000, 217, 223 },    /* 215: p=0.007220 (    1,  183) */
  { 0x24ef,  0x0000,  26,  16 },    /* 216: p=0.199998 (    9,    2) */
  { 0x00e1,  0x0000, 219, 221 },    /* 217: p=0.004750 (    1,  279) */
  { 0x320e,  0x0000,  20, 220 },    /* 218: p=0.269229 (    6,    2) */
  { 0x0094,  0x0000,  71,  63 },    /* 219: p=0.003132 (    1,  424) */
  { 0x432a,  0x0000,  14,   8 },    /* 220: p=0.344827 (    6,    3) */
  { 0x0188,  0x0000,  61,  55 },    /* 221: p=0.008284 (    2,  279) */
  { 0x447d,  0x0000,  14, 224 },    /* 222: p=0.349998 (    4,    2) */
  { 0x0252,  0x0000,  57,  51 },    /* 223: p=0.012567 (    2,  183) */
  { 0x5ece,  0x0000,   8,   2 },    /* 224: p=0.434782 (    4,    3) */
  { 0x0383,  0x0000,  53,  47 },    /* 225: p=0.019021 (    2,  120) */
  { 0x8000,  0x0000, 228,  87 },    /* 226: p=0.500000 (    1,    1) */
  { 0x0547,  0x0000,  49,  43 },    /* 227: p=0.028571 (    2,   79) */
  { 0x481a,  0x0000, 230, 246 },    /* 228: p=0.363634 (    2,    1) */
  { 0x07e2,  0x0000,  45,  37 },    /* 229: p=0.042682 (    2,   52) */
  { 0x3579,  0x0000, 232, 244 },    /* 230: p=0.285711 (    3,    1) */
  { 0x0bc0,  0x0000,  39,  33 },    /* 231: p=0.063636 (    2,   34) */
  { 0x24ef,  0x0000, 234, 238 },    /* 232: p=0.199997 (    5,    1) */
  { 0x1178,  0x0000,  35,  27 },    /* 233: p=0.094593 (    2,   22) */
  { 0x1978,  0x0000, 138, 236 },    /* 234: p=0.137929 (    8,    1) */
  { 0x19da,  0x0000,  29,  21 },    /* 235: p=0.139999 (    2,   14) */
  { 0x2865,  0x0000,  24,  16 },    /* 236: p=0.218748 (    8,    2) */
  { 0x24ef,  0x0000,  25,  15 },    /* 237: p=0.199998 (    2,    9) */
  { 0x3987,  0x0000, 240,   8 },    /* 238: p=0.304346 (    5,    2) */
  { 0x320e,  0x0000,  19, 241 },    /* 239: p=0.269229 (    2,    6) */
  { 0x2c99,  0x0000,  22, 242 },    /* 240: p=0.241378 (    7,    2) */
  { 0x432a,  0x0000,  13,   7 },    /* 241: p=0.344827 (    3,    6) */
  { 0x3b5f,  0x0000,  16,  10 },    /* 242: p=0.312499 (    7,    3) */
  { 0x447d,  0x0000,  13, 245 },    /* 243: p=0.349998 (    2,    4) */
  { 0x5695,  0x0000,  10,   2 },    /* 244: p=0.411764 (    3,    2) */
  { 0x5ece,  0x0000,   7,   1 },    /* 245: p=0.434782 (    3,    4) */
  { 0x8000,  0x0000, 244,  83 },    /* 246: p=0.500000 (    2,    2) */
  { 0x8000,  0x0000, 249, 250 },    /* 247: p=0.500000 (    1,    1) */
  { 0x5695,  0x0000,  10,   2 },    /* 248: p=0.411764 (    3,    2) */
  { 0x481a,  0x0000,  89, 143 },    /* 249: p=0.363634 (    1,    2) */
  { 0x481a,  0x0000, 230, 246 },    /* 250: p=0.363634 (    2,    1) */
#endif
#ifdef ZCODER
  /* This table has been designed for the ZCoder
   * by running the following command in file 'ztable2.sn':
   * (fast-crude (steady-mat 0.0035  0.0002) 260)))
   */
  { 0x8000,  0x0000,  84, 139 },    /* 000: p=0.500000 (    0,    0) */
  { 0x8000,  0x0000,   3,   4 },    /* 001: p=0.500000 (    0,    0) */
  { 0x8000,  0x0000,   4,   3 },    /* 002: p=0.500000 (    0,    0) */
  { 0x7399,  0x10a5,   5,   1 },    /* 003: p=0.465226 (    0,    0) */
  { 0x7399,  0x10a5,   6,   2 },    /* 004: p=0.465226 (    0,    0) */
  { 0x6813,  0x1f28,   7,   3 },    /* 005: p=0.430708 (    0,    0) */
  { 0x6813,  0x1f28,   8,   4 },    /* 006: p=0.430708 (    0,    0) */
  { 0x5d65,  0x2bd3,   9,   5 },    /* 007: p=0.396718 (    0,    0) */
  { 0x5d65,  0x2bd3,  10,   6 },    /* 008: p=0.396718 (    0,    0) */
  { 0x5387,  0x36e3,  11,   7 },    /* 009: p=0.363535 (    0,    0) */
  { 0x5387,  0x36e3,  12,   8 },    /* 010: p=0.363535 (    0,    0) */
  { 0x4a73,  0x408c,  13,   9 },    /* 011: p=0.331418 (    0,    0) */
  { 0x4a73,  0x408c,  14,  10 },    /* 012: p=0.331418 (    0,    0) */
  { 0x421f,  0x48fe,  15,  11 },    /* 013: p=0.300562 (    0,    0) */
  { 0x421f,  0x48fe,  16,  12 },    /* 014: p=0.300562 (    0,    0) */
  { 0x3a85,  0x5060,  17,  13 },    /* 015: p=0.271166 (    0,    0) */
  { 0x3a85,  0x5060,  18,  14 },    /* 016: p=0.271166 (    0,    0) */
  { 0x339b,  0x56d3,  19,  15 },    /* 017: p=0.243389 (    0,    0) */
  { 0x339b,  0x56d3,  20,  16 },    /* 018: p=0.243389 (    0,    0) */
  { 0x2d59,  0x5c73,  21,  17 },    /* 019: p=0.217351 (    0,    0) */
  { 0x2d59,  0x5c73,  22,  18 },    /* 020: p=0.217351 (    0,    0) */
  { 0x27b3,  0x615e,  23,  19 },    /* 021: p=0.193091 (    0,    0) */
  { 0x27b3,  0x615e,  24,  20 },    /* 022: p=0.193091 (    0,    0) */
  { 0x22a1,  0x65a7,  25,  21 },    /* 023: p=0.170683 (    0,    0) */
  { 0x22a1,  0x65a7,  26,  22 },    /* 024: p=0.170683 (    0,    0) */
  { 0x1e19,  0x6963,  27,  23 },    /* 025: p=0.150134 (    0,    0) */
  { 0x1e19,  0x6963,  28,  24 },    /* 026: p=0.150134 (    0,    0) */
  { 0x1a0f,  0x6ca3,  29,  25 },    /* 027: p=0.131397 (    0,    0) */
  { 0x1a0f,  0x6ca3,  30,  26 },    /* 028: p=0.131397 (    0,    0) */
  { 0x167b,  0x6f75,  31,  27 },    /* 029: p=0.114441 (    0,    0) */
  { 0x167b,  0x6f75,  32,  28 },    /* 030: p=0.114441 (    0,    0) */
  { 0x1353,  0x71e6,  33,  29 },    /* 031: p=0.099214 (    0,    0) */
  { 0x1353,  0x71e6,  34,  30 },    /* 032: p=0.099214 (    0,    0) */
  { 0x108d,  0x7403,  35,  31 },    /* 033: p=0.085616 (    0,    0) */
  { 0x108d,  0x7403,  36,  32 },    /* 034: p=0.085616 (    0,    0) */
  { 0x0e1f,  0x75d7,  37,  33 },    /* 035: p=0.073525 (    0,    0) */
  { 0x0e1f,  0x75d7,  38,  34 },    /* 036: p=0.073525 (    0,    0) */
  { 0x0c01,  0x7769,  39,  35 },    /* 037: p=0.062871 (    0,    0) */
  { 0x0c01,  0x7769,  40,  36 },    /* 038: p=0.062871 (    0,    0) */
  { 0x0a2b,  0x78c2,  41,  37 },    /* 039: p=0.053524 (    0,    0) */
  { 0x0a2b,  0x78c2,  42,  38 },    /* 040: p=0.053524 (    0,    0) */
  { 0x0895,  0x79ea,  43,  39 },    /* 041: p=0.045374 (    0,    0) */
  { 0x0895,  0x79ea,  44,  40 },    /* 042: p=0.045374 (    0,    0) */
  { 0x0737,  0x7ae7,  45,  41 },    /* 043: p=0.038280 (    0,    0) */
  { 0x0737,  0x7ae7,  46,  42 },    /* 044: p=0.038280 (    0,    0) */
  { 0x060b,  0x7bbe,  47,  43 },    /* 045: p=0.032175 (    0,    0) */
  { 0x060b,  0x7bbe,  48,  44 },    /* 046: p=0.032175 (    0,    0) */
  { 0x050b,  0x7c75,  49,  45 },    /* 047: p=0.026926 (    0,    0) */
  { 0x050b,  0x7c75,  50,  46 },    /* 048: p=0.026926 (    0,    0) */
  { 0x0431,  0x7d10,  51,  47 },    /* 049: p=0.022430 (    0,    0) */
  { 0x0431,  0x7d10,  52,  48 },    /* 050: p=0.022430 (    0,    0) */
  { 0x0379,  0x7d92,  53,  49 },    /* 051: p=0.018623 (    0,    0) */
  { 0x0379,  0x7d92,  54,  50 },    /* 052: p=0.018623 (    0,    0) */
  { 0x02dd,  0x7dff,  55,  51 },    /* 053: p=0.015386 (    0,    0) */
  { 0x02dd,  0x7dff,  56,  52 },    /* 054: p=0.015386 (    0,    0) */
  { 0x025b,  0x7e5b,  57,  53 },    /* 055: p=0.012671 (    0,    0) */
  { 0x025b,  0x7e5b,  58,  54 },    /* 056: p=0.012671 (    0,    0) */
  { 0x01ef,  0x7ea7,  59,  55 },    /* 057: p=0.010414 (    0,    0) */
  { 0x01ef,  0x7ea7,  60,  56 },    /* 058: p=0.010414 (    0,    0) */
  { 0x0195,  0x7ee6,  61,  57 },    /* 059: p=0.008529 (    0,    0) */
  { 0x0195,  0x7ee6,  62,  58 },    /* 060: p=0.008529 (    0,    0) */
  { 0x0149,  0x7f1b,  63,  59 },    /* 061: p=0.006935 (    0,    0) */
  { 0x0149,  0x7f1b,  64,  60 },    /* 062: p=0.006935 (    0,    0) */
  { 0x010b,  0x7f46,  65,  61 },    /* 063: p=0.005631 (    0,    0) */
  { 0x010b,  0x7f46,  66,  62 },    /* 064: p=0.005631 (    0,    0) */
  { 0x00d5,  0x7f6c,  67,  63 },    /* 065: p=0.004495 (    0,    0) */
  { 0x00d5,  0x7f6c,  68,  64 },    /* 066: p=0.004495 (    0,    0) */
  { 0x00a5,  0x7f8d,  69,  65 },    /* 067: p=0.003484 (    0,    0) */
  { 0x00a5,  0x7f8d,  70,  66 },    /* 068: p=0.003484 (    0,    0) */
  { 0x007b,  0x7faa,  71,  67 },    /* 069: p=0.002592 (    0,    0) */
  { 0x007b,  0x7faa,  72,  68 },    /* 070: p=0.002592 (    0,    0) */
  { 0x0057,  0x7fc3,  73,  69 },    /* 071: p=0.001835 (    0,    0) */
  { 0x0057,  0x7fc3,  74,  70 },    /* 072: p=0.001835 (    0,    0) */
  { 0x0039,  0x7fd8,  75,  71 },    /* 073: p=0.001211 (    0,    0) */
  { 0x0039,  0x7fd8,  76,  72 },    /* 074: p=0.001211 (    0,    0) */
  { 0x0023,  0x7fe7,  77,  73 },    /* 075: p=0.000740 (    0,    0) */
  { 0x0023,  0x7fe7,  78,  74 },    /* 076: p=0.000740 (    0,    0) */
  { 0x0013,  0x7ff2,  79,  75 },    /* 077: p=0.000402 (    0,    0) */
  { 0x0013,  0x7ff2,  80,  76 },    /* 078: p=0.000402 (    0,    0) */
  { 0x0007,  0x7ffa,  81,  77 },    /* 079: p=0.000153 (    0,    0) */
  { 0x0007,  0x7ffa,  82,  78 },    /* 080: p=0.000153 (    0,    0) */
  { 0x0001,  0x7fff,  81,  79 },    /* 081: p=0.000027 (    0,    0) */
  { 0x0001,  0x7fff,  82,  80 },    /* 082: p=0.000027 (    0,    0) */
  { 0x620b,  0x0000,   9,  85 },    /* 083: p=0.411764 (    2,    3) */
  { 0x294a,  0x0000,  86, 216 },    /* 084: p=0.199988 (    1,    0) */
  { 0x8000,  0x0000,   5,   6 },    /* 085: p=0.500000 (    3,    3) */
  { 0x0db3,  0x0000,  88, 168 },    /* 086: p=0.071422 (    4,    0) */
  { 0x538e,  0x0000,  89, 137 },    /* 087: p=0.363634 (    1,    2) */
  { 0x0490,  0x0000,  90, 134 },    /* 088: p=0.024388 (   13,    0) */
  { 0x3e3e,  0x0000,  91, 135 },    /* 089: p=0.285711 (    1,    3) */
  { 0x017c,  0x0000,  92, 112 },    /* 090: p=0.007999 (   41,    0) */
  { 0x294a,  0x0000,  93, 133 },    /* 091: p=0.199997 (    1,    5) */
  { 0x007c,  0x0000,  94, 104 },    /* 092: p=0.002611 (  127,    0) */
  { 0x1b75,  0x0000,  95, 131 },    /* 093: p=0.137929 (    1,    8) */
  { 0x0028,  0x0000,  96, 100 },    /* 094: p=0.000849 (  392,    0) */
  { 0x12fc,  0x0000,  97, 129 },    /* 095: p=0.097559 (    1,   12) */
  { 0x000d,  0x0000,  82,  98 },    /* 096: p=0.000276 ( 1208,    0) */
  { 0x0cfb,  0x0000,  99, 125 },    /* 097: p=0.067795 (    1,   18) */
  { 0x0034,  0x0000,  76,  72 },    /* 098: p=0.001102 ( 1208,    1) */
  { 0x08cd,  0x0000, 101, 123 },    /* 099: p=0.046511 (    1,   27) */
  { 0x00a0,  0x0000,  70, 102 },    /* 100: p=0.003387 (  392,    1) */
  { 0x05de,  0x0000, 103, 119 },    /* 101: p=0.031249 (    1,   41) */
  { 0x0118,  0x0000,  66,  60 },    /* 102: p=0.005912 (  392,    2) */
  { 0x03e9,  0x0000, 105, 117 },    /* 103: p=0.020942 (    1,   62) */
  { 0x01ed,  0x0000, 106, 110 },    /* 104: p=0.010362 (  127,    1) */
  { 0x0298,  0x0000, 107, 115 },    /* 105: p=0.013937 (    1,   94) */
  { 0x0145,  0x0000,  66, 108 },    /* 106: p=0.006849 (  193,    1) */
  { 0x01b6,  0x0000, 109, 113 },    /* 107: p=0.009216 (    1,  143) */
  { 0x0237,  0x0000,  60,  54 },    /* 108: p=0.011925 (  193,    2) */
  { 0x0121,  0x0000,  65, 111 },    /* 109: p=0.006097 (    1,  217) */
  { 0x035b,  0x0000,  56,  48 },    /* 110: p=0.017995 (  127,    2) */
  { 0x01f9,  0x0000,  59,  53 },    /* 111: p=0.010622 (    2,  217) */
  { 0x05de,  0x0000, 114, 130 },    /* 112: p=0.031249 (   41,    1) */
  { 0x02fc,  0x0000,  55,  49 },    /* 113: p=0.016018 (    2,  143) */
  { 0x03e9,  0x0000, 116, 128 },    /* 114: p=0.020942 (   62,    1) */
  { 0x0484,  0x0000,  51,  45 },    /* 115: p=0.024138 (    2,   94) */
  { 0x0298,  0x0000, 118, 126 },    /* 116: p=0.013937 (   94,    1) */
  { 0x06ca,  0x0000,  47,  39 },    /* 117: p=0.036082 (    2,   62) */
  { 0x01b6,  0x0000, 120, 124 },    /* 118: p=0.009216 (  143,    1) */
  { 0x0a27,  0x0000,  41, 121 },    /* 119: p=0.053434 (    2,   41) */
  { 0x0121,  0x0000,  66, 122 },    /* 120: p=0.006097 (  217,    1) */
  { 0x0e57,  0x0000,  37,  31 },    /* 121: p=0.074626 (    3,   41) */
  { 0x01f9,  0x0000,  60,  54 },    /* 122: p=0.010622 (  217,    2) */
  { 0x0f25,  0x0000,  37,  29 },    /* 123: p=0.078651 (    2,   27) */
  { 0x02fc,  0x0000,  56,  50 },    /* 124: p=0.016018 (  143,    2) */
  { 0x1629,  0x0000,  33, 127 },    /* 125: p=0.112902 (    2,   18) */
  { 0x0484,  0x0000,  52,  46 },    /* 126: p=0.024138 (   94,    2) */
  { 0x1ee8,  0x0000,  27,  21 },    /* 127: p=0.153845 (    3,   18) */
  { 0x06ca,  0x0000,  48,  40 },    /* 128: p=0.036082 (   62,    2) */
  { 0x200f,  0x0000,  27,  19 },    /* 129: p=0.159089 (    2,   12) */
  { 0x0a27,  0x0000,  42, 132 },    /* 130: p=0.053434 (   41,    2) */
  { 0x2dae,  0x0000,  21,  15 },    /* 131: p=0.218748 (    2,    8) */
  { 0x0e57,  0x0000,  38,  32 },    /* 132: p=0.074626 (   41,    3) */
  { 0x4320,  0x0000,  15,   7 },    /* 133: p=0.304346 (    2,    5) */
  { 0x11a0,  0x0000, 136, 164 },    /* 134: p=0.090907 (   13,    1) */
  { 0x620b,  0x0000,   9,  85 },    /* 135: p=0.411764 (    2,    3) */
  { 0x0bbe,  0x0000, 138, 162 },    /* 136: p=0.061537 (   20,    1) */
  { 0x8000,  0x0000, 135, 248 },    /* 137: p=0.500000 (    2,    2) */
  { 0x07f3,  0x0000, 140, 160 },    /* 138: p=0.042104 (   30,    1) */
  { 0x294a,  0x0000, 141, 247 },    /* 139: p=0.199988 (    0,    1) */
  { 0x053e,  0x0000, 142, 158 },    /* 140: p=0.027971 (   46,    1) */
  { 0x0db3,  0x0000, 143, 199 },    /* 141: p=0.071422 (    0,    4) */
  { 0x0378,  0x0000, 144, 156 },    /* 142: p=0.018604 (   70,    1) */
  { 0x0490,  0x0000, 145, 167 },    /* 143: p=0.024388 (    0,   13) */
  { 0x024d,  0x0000, 146, 154 },    /* 144: p=0.012384 (  106,    1) */
  { 0x017c,  0x0000, 147, 101 },    /* 145: p=0.007999 (    0,   41) */
  { 0x0185,  0x0000, 148, 152 },    /* 146: p=0.008197 (  161,    1) */
  { 0x007c,  0x0000, 149, 159 },    /* 147: p=0.002611 (    0,  127) */
  { 0x0100,  0x0000,  68, 150 },    /* 148: p=0.005405 (  245,    1) */
  { 0x0028,  0x0000, 151, 155 },    /* 149: p=0.000849 (    0,  392) */
  { 0x01c0,  0x0000,  62,  56 },    /* 150: p=0.009421 (  245,    2) */
  { 0x000d,  0x0000,  81, 153 },    /* 151: p=0.000276 (    0, 1208) */
  { 0x02a7,  0x0000,  58,  52 },    /* 152: p=0.014256 (  161,    2) */
  { 0x0034,  0x0000,  75,  71 },    /* 153: p=0.001102 (    1, 1208) */
  { 0x0403,  0x0000,  54,  46 },    /* 154: p=0.021472 (  106,    2) */
  { 0x00a0,  0x0000,  69, 157 },    /* 155: p=0.003387 (    1,  392) */
  { 0x0608,  0x0000,  48,  42 },    /* 156: p=0.032110 (   70,    2) */
  { 0x0118,  0x0000,  65,  59 },    /* 157: p=0.005912 (    2,  392) */
  { 0x0915,  0x0000,  44,  38 },    /* 158: p=0.047945 (   46,    2) */
  { 0x01ed,  0x0000, 161, 165 },    /* 159: p=0.010362 (    1,  127) */
  { 0x0db4,  0x0000,  40,  32 },    /* 160: p=0.071428 (   30,    2) */
  { 0x0145,  0x0000,  65, 163 },    /* 161: p=0.006849 (    1,  193) */
  { 0x1417,  0x0000,  34,  26 },    /* 162: p=0.102940 (   20,    2) */
  { 0x0237,  0x0000,  59,  53 },    /* 163: p=0.011925 (    2,  193) */
  { 0x1dd6,  0x0000,  30, 166 },    /* 164: p=0.148935 (   13,    2) */
  { 0x035b,  0x0000,  55,  47 },    /* 165: p=0.017995 (    2,  127) */
  { 0x294a,  0x0000,  24,  18 },    /* 166: p=0.199999 (   13,    3) */
  { 0x11a0,  0x0000, 169, 195 },    /* 167: p=0.090907 (    1,   13) */
  { 0x31a3,  0x0000, 170, 212 },    /* 168: p=0.235291 (    4,    1) */
  { 0x0bbe,  0x0000, 171, 193 },    /* 169: p=0.061537 (    1,   20) */
  { 0x235a,  0x0000, 172, 208 },    /* 170: p=0.173910 (    6,    1) */
  { 0x07f3,  0x0000, 173, 191 },    /* 171: p=0.042104 (    1,   30) */
  { 0x18b3,  0x0000, 174, 206 },    /* 172: p=0.124998 (    9,    1) */
  { 0x053e,  0x0000, 175, 189 },    /* 173: p=0.027971 (    1,   46) */
  { 0x1073,  0x0000, 176, 204 },    /* 174: p=0.085105 (   14,    1) */
  { 0x0378,  0x0000, 177, 187 },    /* 175: p=0.018604 (    1,   70) */
  { 0x0b35,  0x0000, 178, 200 },    /* 176: p=0.058822 (   21,    1) */
  { 0x024d,  0x0000, 179, 185 },    /* 177: p=0.012384 (    1,  106) */
  { 0x0778,  0x0000, 180, 198 },    /* 178: p=0.039603 (   32,    1) */
  { 0x0185,  0x0000, 181, 183 },    /* 179: p=0.008197 (    1,  161) */
  { 0x04ed,  0x0000, 182, 194 },    /* 180: p=0.026315 (   49,    1) */
  { 0x0100,  0x0000,  67,  59 },    /* 181: p=0.005405 (    1,  245) */
  { 0x0349,  0x0000, 184, 192 },    /* 182: p=0.017621 (   74,    1) */
  { 0x02a7,  0x0000,  57,  51 },    /* 183: p=0.014256 (    2,  161) */
  { 0x022e,  0x0000, 186, 190 },    /* 184: p=0.011730 (  112,    1) */
  { 0x0403,  0x0000,  53,  45 },    /* 185: p=0.021472 (    2,  106) */
  { 0x0171,  0x0000,  64, 188 },    /* 186: p=0.007767 (  170,    1) */
  { 0x0608,  0x0000,  47,  41 },    /* 187: p=0.032110 (    2,   70) */
  { 0x0283,  0x0000,  58,  52 },    /* 188: p=0.013513 (  170,    2) */
  { 0x0915,  0x0000,  43,  37 },    /* 189: p=0.047945 (    2,   46) */
  { 0x03cc,  0x0000,  54,  48 },    /* 190: p=0.020349 (  112,    2) */
  { 0x0db4,  0x0000,  39,  31 },    /* 191: p=0.071428 (    2,   30) */
  { 0x05b6,  0x0000,  50,  42 },    /* 192: p=0.030434 (   74,    2) */
  { 0x1417,  0x0000,  33,  25 },    /* 193: p=0.102940 (    2,   20) */
  { 0x088a,  0x0000,  44, 196 },    /* 194: p=0.045161 (   49,    2) */
  { 0x1dd6,  0x0000,  29, 197 },    /* 195: p=0.148935 (    2,   13) */
  { 0x0c16,  0x0000,  40,  34 },    /* 196: p=0.063291 (   49,    3) */
  { 0x294a,  0x0000,  23,  17 },    /* 197: p=0.199999 (    3,   13) */
  { 0x0ce2,  0x0000,  40,  32 },    /* 198: p=0.067307 (   32,    2) */
  { 0x31a3,  0x0000, 201, 243 },    /* 199: p=0.235291 (    1,    4) */
  { 0x1332,  0x0000,  36, 202 },    /* 200: p=0.098590 (   21,    2) */
  { 0x235a,  0x0000, 203, 239 },    /* 201: p=0.173910 (    1,    6) */
  { 0x1adc,  0x0000,  30,  24 },    /* 202: p=0.135134 (   21,    3) */
  { 0x18b3,  0x0000, 205, 237 },    /* 203: p=0.124998 (    1,    9) */
  { 0x1be7,  0x0000,  30,  22 },    /* 204: p=0.139999 (   14,    2) */
  { 0x1073,  0x0000, 207, 235 },    /* 205: p=0.085105 (    1,   14) */
  { 0x294a,  0x0000,  26,  16 },    /* 206: p=0.199998 (    9,    2) */
  { 0x0b35,  0x0000, 209, 231 },    /* 207: p=0.058822 (    1,   21) */
  { 0x3a07,  0x0000,  20, 210 },    /* 208: p=0.269229 (    6,    2) */
  { 0x0778,  0x0000, 211, 229 },    /* 209: p=0.039603 (    1,   32) */
  { 0x4e30,  0x0000,  14,   8 },    /* 210: p=0.344827 (    6,    3) */
  { 0x04ed,  0x0000, 213, 225 },    /* 211: p=0.026315 (    1,   49) */
  { 0x4fa6,  0x0000,  14, 214 },    /* 212: p=0.349998 (    4,    2) */
  { 0x0349,  0x0000, 215, 223 },    /* 213: p=0.017621 (    1,   74) */
  { 0x6966,  0x0000,   8,   2 },    /* 214: p=0.434782 (    4,    3) */
  { 0x022e,  0x0000, 217, 221 },    /* 215: p=0.011730 (    1,  112) */
  { 0x8000,  0x0000, 218,  87 },    /* 216: p=0.500000 (    1,    1) */
  { 0x0171,  0x0000,  63, 219 },    /* 217: p=0.007767 (    1,  170) */
  { 0x538e,  0x0000, 220, 246 },    /* 218: p=0.363634 (    2,    1) */
  { 0x0283,  0x0000,  57,  51 },    /* 219: p=0.013513 (    2,  170) */
  { 0x3e3e,  0x0000, 222, 244 },    /* 220: p=0.285711 (    3,    1) */
  { 0x03cc,  0x0000,  53,  47 },    /* 221: p=0.020349 (    2,  112) */
  { 0x294a,  0x0000, 224, 242 },    /* 222: p=0.199997 (    5,    1) */
  { 0x05b6,  0x0000,  49,  41 },    /* 223: p=0.030434 (    2,   74) */
  { 0x1b75,  0x0000, 226, 240 },    /* 224: p=0.137929 (    8,    1) */
  { 0x088a,  0x0000,  43, 227 },    /* 225: p=0.045161 (    2,   49) */
  { 0x12fc,  0x0000, 228, 238 },    /* 226: p=0.097559 (   12,    1) */
  { 0x0c16,  0x0000,  39,  33 },    /* 227: p=0.063291 (    3,   49) */
  { 0x0cfb,  0x0000, 230, 234 },    /* 228: p=0.067795 (   18,    1) */
  { 0x0ce2,  0x0000,  39,  31 },    /* 229: p=0.067307 (    2,   32) */
  { 0x08cd,  0x0000, 112, 232 },    /* 230: p=0.046511 (   27,    1) */
  { 0x1332,  0x0000,  35, 233 },    /* 231: p=0.098590 (    2,   21) */
  { 0x0f25,  0x0000,  38,  30 },    /* 232: p=0.078651 (   27,    2) */
  { 0x1adc,  0x0000,  29,  23 },    /* 233: p=0.135134 (    3,   21) */
  { 0x1629,  0x0000,  34, 236 },    /* 234: p=0.112902 (   18,    2) */
  { 0x1be7,  0x0000,  29,  21 },    /* 235: p=0.139999 (    2,   14) */
  { 0x1ee8,  0x0000,  28,  22 },    /* 236: p=0.153845 (   18,    3) */
  { 0x294a,  0x0000,  25,  15 },    /* 237: p=0.199998 (    2,    9) */
  { 0x200f,  0x0000,  28,  20 },    /* 238: p=0.159089 (   12,    2) */
  { 0x3a07,  0x0000,  19, 241 },    /* 239: p=0.269229 (    2,    6) */
  { 0x2dae,  0x0000,  22,  16 },    /* 240: p=0.218748 (    8,    2) */
  { 0x4e30,  0x0000,  13,   7 },    /* 241: p=0.344827 (    3,    6) */
  { 0x4320,  0x0000,  16,   8 },    /* 242: p=0.304346 (    5,    2) */
  { 0x4fa6,  0x0000,  13, 245 },    /* 243: p=0.349998 (    2,    4) */
  { 0x620b,  0x0000,  10,   2 },    /* 244: p=0.411764 (    3,    2) */
  { 0x6966,  0x0000,   7,   1 },    /* 245: p=0.434782 (    3,    4) */
  { 0x8000,  0x0000, 244,  83 },    /* 246: p=0.500000 (    2,    2) */
  { 0x8000,  0x0000, 249, 250 },    /* 247: p=0.500000 (    1,    1) */
  { 0x620b,  0x0000,  10,   2 },    /* 248: p=0.411764 (    3,    2) */
  { 0x538e,  0x0000,  89, 137 },    /* 249: p=0.363634 (    1,    2) */
  { 0x538e,  0x0000, 220, 246 },    /* 250: p=0.363634 (    2,    1) */
#endif
};



////////////////////////////////////////////////////////////////
// CONSTRUCTOR/DESTRUCTOR
////////////////////////////////////////////////////////////////

class ZPCodec::Encode : public ZPCodec
{
public:
  Encode(GP<ByteStream> gbs, const bool djvucompat);
  virtual ~Encode();
private:
  void init(void); 
};

ZPCodec::Encode::Encode(GP<ByteStream> gbs, const bool djvucompat)
: ZPCodec(gbs,true,djvucompat)
{
  init();
  // Codebit counter
#ifdef ZPCODEC_BITCOUNT
  bitcount = 0;
#endif
}

ZPCodec::Encode::~Encode()
{
  eflush();
}
 
class ZPCodec::Decode : public ZPCodec
{
public:
  Decode(GP<ByteStream> gbs, const bool djvucompat);
  virtual ~Decode();
private:
  void init(void); 
};

ZPCodec::Decode::Decode(GP<ByteStream> gbs, const bool djvucompat)
: ZPCodec(gbs,false,djvucompat)
{
  init();
  // Codebit counter
#ifdef ZPCODEC_BITCOUNT
  bitcount = 0;
#endif
}
 
ZPCodec::Decode::~Decode() {}

ZPCodec::ZPCodec(GP<ByteStream> xgbs, const bool xencoding, const bool djvucompat)
: gbs(xgbs), bs(xgbs), encoding(xencoding), fence(0), subend(0), buffer(0), nrun(0)
{
  // Create machine independent ffz table
  for (int i=0; i<256; i++)
    {
      ffzt[i]=0;
      for (int j=i; j&0x80; j<<=1)
        ffzt[i] += 1;
    }
  // Initialize table
  newtable(default_ztable);
  // Patch table table (and lose DjVu compatibility).
  if (!djvucompat)
    {
      for (int j=0; j<256; j++)
        {
          unsigned short a = 0x10000-p[j];
          while (a>=0x8000)  a=(unsigned short)(a<<1);
          if (m[j]>0 && a+p[j]>=0x8000 && a>=m[j])
            {
              BitContext x = default_ztable[j].dn;
              BitContext y = default_ztable[x].dn;
              dn[j] = y;
            }
        }
    }
}

ZPCodec::~ZPCodec() {}

GP<ZPCodec>
ZPCodec::create(GP<ByteStream> gbs, const bool encoding, const bool djvucompat)
{
  GP<ZPCodec> retval;
  if(encoding)
  {
    retval=new ZPCodec::Encode(gbs,djvucompat);
  }else
  {
    retval=new ZPCodec::Decode(gbs,djvucompat);
  }
  return retval;
}

////////////////////////////////////////////////////////////////
// Z CODER DECODE ALGORITHM
////////////////////////////////////////////////////////////////



void 
ZPCodec::Decode::init(void)
{
  assert(sizeof(unsigned int)==4);
  assert(sizeof(unsigned short)==2);
  a = 0;
  /* Read first 16 bits of code */
  if (! bs->read((void*)&byte, 1))
    byte = 0xff;
  code = (byte<<8);
  if (! bs->read((void*)&byte, 1))
    byte = 0xff;
  code = code | byte;
  /* Preload buffer */
  delay = 25;
  scount = 0;
  preload();
  /* Compute initial fence */
  fence = code;
  if (code >= 0x8000)
    fence = 0x7fff;
}


void
ZPCodec::preload(void)
{
  while (scount<=24)
    {
      if (bs->read((void*)&byte, 1) < 1) 
        {
          byte = 0xff;
          if (--delay < 1)
            G_THROW( ByteStream::EndOfFile );
        }
      buffer = (buffer<<8) | byte;
      scount += 8;
    }
}


inline int
ZPCodec::ffz(unsigned int x)
{
  // DO NOT DEFINE FASTBSR : 
  // Test shows that it hardly helps on a PPro,
  // and rumors are that BSR is very slow on PPlain.
#if defined(FASTBSR) && defined(_MSC_VER) && defined(_M_IX86)
  int r;
  __asm  { 
        mov  ebx, x
        xor  ebx, 0xffff
        mov  eax, -1
        bsr  eax, ebx
        mov  r, eax
  }
  return 15 - r;
#elif defined(FASTBSR) && defined(__GNUC__) && defined(__i386__)
  int r, dummy;
  __asm__ const ( "movl %2,%1\n\t"
                  "xorl $0xffff, %1\n\t"
                  "movl $-1, %0\n\t"
                  "bsrl %1, %0"
                  : "=&q" (r), "=q" (dummy) : "rm" (x) );
  return 15 - r;
#else
  return (x>=0xff00) ? (ffzt[x&0xff]+8) : (ffzt[(x>>8)&0xff]);
#endif
}


int 
ZPCodec::decode_sub(BitContext &ctx, unsigned int z)
{
  /* Save bit */
  int bit = (ctx & 1);
  /* Avoid interval reversion */
#ifdef ZPCODER
  unsigned int d = 0x6000 + ((z+a)>>2);
  if (z > d) 
    z = d;
#endif
#ifdef ZCODER
  if (z >= 0x8000)
    z = 0x4000 + (z>>1);
#endif
  /* Test MPS/LPS */
  if (z > code)
    {
      /* LPS branch */
      z = 0x10000 - z;
      a = a + z;
      code = code + z;
      /* LPS adaptation */
      ctx = dn[ctx];
      /* LPS renormalization */
      int shift = ffz(a);
      scount -= shift;
      a = (unsigned short)(a<<shift);
      code = (unsigned short)(code<<shift) | ((buffer>>scount) & ((1<<shift)-1));
#ifdef ZPCODEC_BITCOUNT
      bitcount += shift;
#endif
      if (scount<16) preload();
      /* Adjust fence */
      fence = code;
      if (code >= 0x8000)
        fence = 0x7fff;
      return bit ^ 1;
    }
  else
    {
      /* MPS adaptation */
      if (a >= m[ctx])
        ctx = up[ctx];
      /* MPS renormalization */
      scount -= 1;
      a = (unsigned short)(z<<1);
      code = (unsigned short)(code<<1) | ((buffer>>scount) & 1);
#ifdef ZPCODEC_BITCOUNT
      bitcount += 1;
#endif
      if (scount<16) preload();
      /* Adjust fence */
      fence = code;
      if (code >= 0x8000)
        fence = 0x7fff;
      return bit;
    }
}


int 
ZPCodec::decode_sub_simple(int mps, unsigned int z)
{
  /* Test MPS/LPS */
  if (z > code)
    {
      /* LPS branch */
      z = 0x10000 - z;
      a = a + z;
      code = code + z;
      /* LPS renormalization */
      int shift = ffz(a);
      scount -= shift;
      a = (unsigned short)(a<<shift);
      code = (unsigned short)(code<<shift) | ((buffer>>scount) & ((1<<shift)-1));
#ifdef ZPCODEC_BITCOUNT
      bitcount += shift;
#endif
      if (scount<16) preload();
      /* Adjust fence */
      fence = code;
      if (code >= 0x8000)
        fence = 0x7fff;
      return mps ^ 1;
    }
  else
    {
      /* MPS renormalization */
      scount -= 1;
      a = (unsigned short)(z<<1);
      code = (unsigned short)(code<<1) | ((buffer>>scount) & 1);
#ifdef ZPCODEC_BITCOUNT
      bitcount += 1;
#endif
      if (scount<16) preload();
      /* Adjust fence */
      fence = code;
      if (code >= 0x8000)
        fence = 0x7fff;
      return mps;
    }
}


int  
ZPCodec::decode_sub_nolearn(int mps, unsigned int z)
{
#ifdef ZPCODER
  unsigned int d = 0x6000 + ((z+a)>>2);
  if (z > d) 
        z = d;
#endif
#ifdef ZCODER
  if (z >= 0x8000)
    z = 0x4000 + (z>>1);
#endif
  /* Test MPS/LPS */
  if (z > code)
    {
      /* LPS branch */
      z = 0x10000 - z;
      a = a + z;
      code = code + z;
      /* LPS renormalization */
      int shift = ffz(a);
      scount -= shift;
      a = (unsigned short)(a<<shift);
      code = (unsigned short)(code<<shift) | ((buffer>>scount) & ((1<<shift)-1));
#ifdef ZPCODEC_BITCOUNT
      bitcount += shift;
#endif
      if (scount<16) preload();
      /* Adjust fence */
      fence = code;
      if (code >= 0x8000)
        fence = 0x7fff;
      return mps ^ 1;
    }
  else
    {
      /* MPS renormalization */
      scount -= 1;
      a = (unsigned short)(z<<1);
      code = (unsigned short)(code<<1) | ((buffer>>scount) & 1);
#ifdef ZPCODEC_BITCOUNT
      bitcount += 1;
#endif
      if (scount<16) preload();
      /* Adjust fence */
      fence = code;
      if (code >= 0x8000)
        fence = 0x7fff;
      return mps;
    }
}





////////////////////////////////////////////////////////////////
// Z CODER ENCODE ALGORITHM
////////////////////////////////////////////////////////////////




void 
ZPCodec::Encode::init(void)
{
  assert(sizeof(unsigned int)==4);
  assert(sizeof(unsigned short)==2);
  a = 0;
  scount = 0;
  byte = 0;
  delay = 25;
  subend = 0;
  buffer = 0xffffff;
  nrun = 0;
}

void
ZPCodec::outbit(int bit)
{
  if (delay > 0)
    {
      if (delay < 0xff) // delay=0xff suspends emission forever
        delay -= 1;
    }
  else
    {
      /* Insert a bit */
      byte = (byte<<1) | bit;
      /* Output a byte */
      if (++scount == 8)
        {
          if (!encoding)
            G_THROW( ERR_MSG("ZPCodec.no_encoding") );
          if (bs->write((void*)&byte, 1) != 1)
            G_THROW( ERR_MSG("ZPCodec.write_error") );
          scount = 0;
          byte = 0;
        }
    }
}

void 
ZPCodec::zemit(int b)
{
  /* Shift new bit into 3bytes buffer */
  buffer = (buffer<<1) + b;
  /* Examine bit going out of the 3bytes buffer */
  b = (buffer >> 24);
  buffer = (buffer & 0xffffff);
  /* The following lines have been changed in order to emphazise the
   * similarity between this bit counting and the scheme of Witten, Neal & Cleary
   * (WN&C).  Corresponding changes have been made in outbit and eflush.
   * Variable 'nrun' is similar to the 'bits_to_follow' in the W&N code.
   */
  switch(b)
    {
      /* Similar to WN&C upper renormalization */
    case 1:
      outbit(1);
      while (nrun-- > 0)
        outbit(0);
      nrun = 0;
      break;
      /* Similar to WN&C lower renormalization */
    case 0xff:
      outbit(0);
      while (nrun-- > 0)
        outbit(1);
      nrun = 0;
      break;
      /* Similar to WN&C central renormalization */
    case 0:
      nrun += 1;
      break;
    default:
      assert(0);
    }
  /* Code bit counter */
#ifdef ZPCODEC_BITCOUNT
  bitcount += 1;
#endif
}

void 
ZPCodec::eflush()
{
  /* adjust subend */
  if (subend > 0x8000)
    subend = 0x10000;
  else if (subend > 0)
    subend = 0x8000;
  /* zemit many mps bits */
  while (buffer != 0xffffff  || subend )
    {
      zemit(1 - (subend>>15) );
      subend = (unsigned short)(subend<<1);
    }
  /* zemit pending run */
  outbit(1);
  while (nrun-- > 0)
    outbit(0);
  nrun = 0;
  /* zemit 1 until full byte */
  while (scount > 0)
    outbit(1);
  /* prevent further emission */
  delay = 0xff;
}

void 
ZPCodec::encode_mps(BitContext &ctx, unsigned int z)
{
  /* Avoid interval reversion */
#ifdef ZPCODER
  unsigned int d = 0x6000 + ((z+a)>>2);
  if (z > d) 
    z = d;
#endif
#ifdef ZCODER
  if (z >= 0x8000)
    z = 0x4000 + (z>>1);
#endif
  /* Adaptation */
  if (a >= m[ctx])
    ctx = up[ctx];
  /* Code MPS */
  a = z;
  /* Export bits */
  if (a >= 0x8000)
    {
      zemit(1 - (subend>>15) );
      subend = (unsigned short)(subend<<1);
      a = (unsigned short)(a<<1);
    }
}


void 
ZPCodec::encode_lps(BitContext &ctx, unsigned int z)
{
  /* Avoid interval reversion */
#ifdef ZPCODER
  unsigned int d = 0x6000 + ((z+a)>>2);
  if (z > d) 
    z = d;
#endif
#ifdef ZCODER
  if (z >= 0x8000)
    z = 0x4000 + (z>>1);
#endif
  /* Adaptation */
  ctx = dn[ctx];
  /* Code LPS */
  z = 0x10000 - z;
  subend += z;
  a += z;
  /* Export bits */
  while (a >= 0x8000)
    {
      zemit(1 - (subend>>15) );
      subend = (unsigned short)(subend<<1);
      a = (unsigned short)(a<<1);
    }
}


void 
ZPCodec::encode_mps_simple(unsigned int z)
{
  /* Code MPS */
  a = z;
  /* Export bits */
  if (a >= 0x8000)
    {
      zemit(1 - (subend>>15) );
      subend = (unsigned short)(subend<<1);
      a = (unsigned short)(a<<1);
    }
}

void 
ZPCodec::encode_lps_simple(unsigned int z)
{
  /* Code LPS */
  z = 0x10000 - z;
  subend += z;
  a += z;
  /* Export bits */
  while (a >= 0x8000)
    {
      zemit(1 - (subend>>15) );
      subend = (unsigned short)(subend<<1);
      a = (unsigned short)(a<<1);
    }
}


void 
ZPCodec::encode_mps_nolearn(unsigned int z)
{
#ifdef ZPCODER
  unsigned int d = 0x6000 + ((z+a)>>2);
  if (z > d) 
    z = d;
#endif
#ifdef ZCODER
  if (z >= 0x8000)
    z = 0x4000 + (z>>1);
#endif
  /* Code MPS */
  a = z;
  /* Export bits */
  if (a >= 0x8000)
    {
      zemit(1 - (subend>>15) );
      subend = (unsigned short)(subend<<1);
      a = (unsigned short)(a<<1);
    }
}


void 
ZPCodec::encode_lps_nolearn(unsigned int z)
{
#ifdef ZPCODER
  unsigned int d = 0x6000 + ((z+a)>>2);
  if (z > d) 
    z = d;
#endif
#ifdef ZCODER
  if (z >= 0x8000)
    z = 0x4000 + (z>>1);
#endif
  /* Code LPS */
  z = 0x10000 - z;
  subend += z;
  a += z;
  /* Export bits */
  while (a >= 0x8000)
    {
      zemit(1 - (subend>>15) );
      subend = (unsigned short)(subend<<1);
      a = (unsigned short)(a<<1);
    }
}






////////////////////////////////////////////////////////////////
// TABLE AND PARAMETER MANAGEMENT
////////////////////////////////////////////////////////////////




void 
ZPCodec::newtable(ZPCodec::Table *table)
{
  for (int i=0; i<256; i++)
    {
      p[i]  = table[i].p;
      m[i]  = table[i].m;
      up[i] = table[i].up;
      dn[i] = table[i].dn;
    }
}

static float 
p_to_plps(unsigned short p)
{
  float fplps;
  float fp = (float)(p) / (float)(0x10000);
  const float log2 = (float)0.69314718055994530942;
#ifdef ZCODER
  fplps = fp - (fp+0.5) * log(fp+0.5) + (fp-0.5)*log2;
#endif
#ifdef ZPCODER
  if (fp <= (1.0/6.0) )
    fplps = fp * 2 * log2;
  else
    fplps = (float)((1.5*fp-0.25) - (1.5*fp+0.25)*log(1.5*fp+0.25) + (0.5*fp-0.25)*log2);
#endif
  return fplps;
}


BitContext 
ZPCodec::state(float prob1)
{
  // Return a state representing 'prob1' in the steady chain
  // FixMe: This is quite slow! 
  int mps = (prob1 <= 0.5 ? 0 : 1);
  float plps = (float)(mps ? 1.0 - prob1 : prob1);
  // Locate steady chain (ordered, decreasing)
  int sz = 0;
  int lo = (mps ? 1 : 2);
  while (p[lo+sz+sz+2] < p[lo+sz+sz]) sz+=1;
  // Bisection
  while (sz > 1)
    {
      int nsz = sz >> 1;
      float nplps = p_to_plps( p[lo+nsz+nsz] );
      if (nplps < plps)
        { sz=nsz; }
      else
        { lo=lo+nsz+nsz; sz=sz-nsz; }
    }
  // Choose closest one
  float f1 = p_to_plps(p[lo])-plps;
  float f2 = plps-p_to_plps(p[lo+2]);
  return (f1<f2) ? lo : lo+2;
}


#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif
